<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Document</title>
</head>

<body>
    <script>
        // Set： 本质是一个函数
        // 作用： 用来构建某一个类型对象
        // 通常我们把这些类型的函数， 叫做 构造函数

        // Set（） 可以接收 指定目标 来作为参数；
        // 和直接使用的区别： 达成去重的目的
        // let arr = [1, 2, 2, 3, 3, 4, 4, 5];
        // let s = new Set(arr);
        // console.log(s); //size 属性console.log(s.size);

        // let arr = [1, function() {}, 2, 2, 3, 3, 'undefined', 'undefined'];
        // let s = new Set(arr);
        // console.log(s.has('undefined'));



        // Set
        // ES6提供了新的数据结构Set。 它类似于数组， 但是成员的值都是唯一的， 没有重复的值。
        // Set是一个构造函数， 可以传入一个数组初始化默认值。

        // size属性：
        // Set的实例的成员个数（ 数组的长度）


        // add(value) 方法：
        // 为Set的实例添加值
        // 参数： 添加的内容
        // 返回值： 添加后的整体内容
        // console.log(s.add("a").add("b"));

        // delete(value) 方法:
        //     删除Set实例的值
        // 参数： 指定的内容
        // 返回值： true || false 是否删除成功(没有这个值的话， 才会出现不成功)

        // has(value) 方法
        // 判断传入的参数是否为set的成员
        // 参数： 指定的内容
        // 返回值： true || false

        // clear() 方法：
        // 清除set中所有成员
        // 无参 无返回值







        // Map
        // ES6提供了map数据结构。 它类似于对象， 也是键值对的集合， 但是“ 键” 的范围不限于字符串， 各种类型的值（ 包括对象） 都可以当作键。
        // Map也可以接受一个数组作为参数。 该数组的成员是一个个表示键值对的数组。
        // 例如：
        //     [[key1, value1], [key2, value2]]
        // var myMap = new Map();
        // myMap.set(0, '13');
        // map.size
        // 返回成员总数
        // console.log(myMap.size);

        // map.get(key)
        // 通过key获取value
        // console.log(myMap.get(0));

        // map.set(key, value)
        // 为Map的实例添加新键值对
        // console.log(myMap.set(1, 14));

        // map.has(key)
        // 查找key值是否存在。
        // console.log(myMap.has(0));

        // map.delete(key)
        // 删除对应键值对

        // map.clear()
        // 清除所有成员




        // Map的迭代
        // var myMap = new Map();
        // myMap.set(0, "zero");
        // myMap.set(1, "one");
        // // 将会显示两个 logs。 一个是 "0 = zero" 另一个是 "1 = one"
        // myMap.forEach(function(value, key) {
        //     console.log(key + " = " + value);
        // }, myMap)



        // Map和Array的转换
        // var kvArray = [
        //     ['key1', 'value1'],
        //     ['key2', 'value2']
        // ];
        // // Map构造函数可以将一个 二维 键值对数组转换成一个Map对象
        // var myMap = new Map(kvArray);
        // // 使用Array.from函数可以将一个Map 对象转换成一个二维键值对数组
        // var outArray = Array.from(myMap);



        // Map的克隆
        // var myMap1 = new Map([
        //     ['key1', 'value1'],
        //     ['key2', 'value2']
        // ]);
        // var myMap2 = new Map(myMap1);
        // console.log(myMap1 === myMap2);





        // Set 对象
        // Set 对象允许你存储任何类型的唯一值， 无论是原始值或者是对象引用。

        // Set 中的特殊值
        // Set 对象存储的值总是唯一的， 所以需要判断两个值是否恒等。 有几个特殊值需要特殊对待：
        // + 0 与 - 0 在存储判断唯一性的时候是恒等的， 所以不重复；
        // undefined 与 undefined 是恒等的， 所以不重复；
        // NaN 与 NaN 是不恒等的， 但是在 Set 中只能存一个， 不重复。
        // let mySet = new Set();
        // mySet.add(1); // Set(1) {1}
        // mySet.add(5); // Set(2) {1, 5}
        // mySet.add(5); // Set(2) {1, 5} 这里体现了值的唯一性
        // mySet.add("some text");
        // Set(3) {1, 5, "some text"} 这里体现了类型的多样性
        // var o = {
        //     a: 1,
        //     b: 2
        // };
        // mySet.add(o);
        // mySet.add({
        //     a: 1,
        //     b: 2
        // });
        // Set(5) {1, 5, "some text", {…}, {…}} 
        // 这里体现了对象之间引用不同不恒等，即使值相同，Set 也能存储



        // Array转Set
        // var mySet = new Set(['value1', 'value2', 'value3']);
        // 用...操作符,将Set转Array
        // var myArray = [...mySet];

        // String转Set
        // var mySet = new Set('hello');
        // var myArray = [...mySet];




        // 数组去重
        // var mySet = new Set([1, 1, 2, 2, 3, 3, 4, 4]);
        // console.log([...mySet]);


        // 并集
        // var a = new Set([1, 2, 3]);
        // var b = new Set([4, 3, 2]);
        // var union = new Set([...a, ...b]);


        // 交集
        // var a = new Set([1, 2, 3]);
        // var b = new Set([4, 3, 2]);
        // var intersect = new Set([...a].filter(x => b.has(x)));


        // 差集
        // var a = new Set([1, 2, 3]);
        // var b = new Set([4, 3, 2]);
        // var difference = new Set([...a].filter(x => !b.has(x)));
    </script>
</body>

</html>